/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "ui文件对话框.h"
#include "../intern/ui列表.h"

#include "../intern/ui文本编辑.h"
#include "UI/UI.h"


#include <文件/file_文件名数据.h>




#define DEF_文件名编辑框_ID 7



static std::vector<std::string>	g当前要处理文件;
static std::wstring g显示文件名;

static E_对话框类型				g_文件处理方式 = E_对话框类型::e_读取;
static C_超级列表编辑框*        g当前打开列表框的编辑框 = nullptr;




static uint16 gDraw文件列表_属性ID = 0;

DEF_单色绘制ID(编辑框背景);
DEF_文本绘制ID(编辑框文本);

DEF_单色绘制ID(光标);
DEF_单色绘制ID(文本选框);

static uint16 g_快捷栏滚动窗口绘制属性 = 0;
static uint16 g_快捷栏内部组件绘制属性 = 0;






static bool f_文件列表浏览打开关闭(C_列表框* listBox, std::filesystem::path 路径, std::string 后缀, bool 是否包含文件 = true) {
	//C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(self->m_父部件);
	g当前要处理文件.clear();

	S_目录文件包 files;
	if (是否包含文件) {
		f_file_get目录下所有文件名(路径.string(), files, 后缀);
	}
	else {
		f_file_get目录下所有目录名(路径.string(), files);
	}
	


	std::vector<S_列表填充数据> data;
	for (auto& s : files.目录) {
		data.push_back({ "black319", S_UI主题::uic_文件夹, {s, L"", L""} });
	}
	if (是否包含文件) {
		for (auto& s : files.文件) {
			data.push_back({ "document", S_UI主题::uic_文件, {s, L"", L""} });
		}
	}
	
	listBox->f_填充列表(data);

	g当前要处理文件.push_back(路径.string());

	listBox->m_绘制属性更新 = true;
	return true;
}






static void f_目录文件快捷栏绘制(C_Widget* self, S_2D画布* 画布) {
	assert(dynamic_cast<C_目录文件快捷栏*>(self));
	C_目录文件快捷栏* box = (C_目录文件快捷栏*)(self);

	g_快捷栏滚动窗口绘制属性 = f_vg_gen属性(画布);
	g_快捷栏内部组件绘制属性 = f_vg_gen属性(画布);

	S_凸边图元 图元 = {};
	图元.属性 = f_vg_get属性指针(画布, g_快捷栏内部组件绘制属性);
	box->m_背景绘制.f_Draw(画布, 图元, E_笔刷类型::e_条纹);


	图元 = {};
	图元.属性 = f_vg_get属性指针(画布, g_快捷栏内部组件绘制属性);
	box->m_分类板块绘制.f_Draw(画布, 图元, E_笔刷类型::e_单色填充);
	

	图元 = {};
	图元.属性 = f_vg_get属性指针(画布, g_快捷栏滚动窗口绘制属性);
	box->m_滚动组件绘制.f_Draw(画布, 图元, E_笔刷类型::e_单色填充);
	

	auto 字体 = f_surface_get字体(*self->m_UIctx, S_UI主题::ui_默认字体);
	box->m_文字绘制.f_Draw(画布, &字体, g_快捷栏内部组件绘制属性);
}

static void f_目录文件快捷栏变换修改(C_Widget* self) {
	assert(dynamic_cast<C_目录文件快捷栏*>(self));
	C_目录文件快捷栏* 快捷栏 = (C_目录文件快捷栏*)(self);
	


	S_2D顶点属性 属性;
	属性.m_比例 = { 1,1 };
	属性.m_偏移 = {};
	属性.m_渐变数量 = 24;
	属性.m_间隔 = S_UI主题::ui_文字间隔;
	f_vg_set属性(self->m_画布, g_快捷栏滚动窗口绘制属性, 属性);


	auto e = self->f_get更新部件();
	快捷栏->m_滚动组件绘制.f_alloc(1);
	快捷栏->m_分类板块绘制.f_alloc(快捷栏->m_单色块使用计数);
	快捷栏->m_文字绘制.f_alloc(快捷栏->m_单色块使用计数, 100);

	auto 滚动窗口 = e.m_W[0];
	{
		auto soll_e = 滚动窗口->f_get更新部件();

		快捷栏->m_滚动组件绘制.f_绘制滚动条(0, soll_e.m_W[1]);

		auto soll_view = soll_e.m_W[0];
		{
			S_2D顶点属性 属性;
			属性.m_比例 = { 1,1 };
			属性.m_偏移 = soll_view->m_Pos;
			属性.m_间隔 = 2;
			属性.m_渐变数量 = 20;
			f_vg_set属性(self->m_画布, g_快捷栏内部组件绘制属性, 属性);


			auto box = soll_view->f_get更新部件();
			for (uint16 i = 0; i < box.m_Num; ++i) {
				mat3X2 mat;
				mat.row0 = box.m_W[i]->m_Pos;
				mat.row1 = box.m_W[i]->m_Size;
				mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
				快捷栏->m_分类板块绘制.f_set单色填充(i, mat, S_UI主题::uic_面板背景, S_Widget预设图元::m_圆角矩形);

				mat.row0.x += box.m_W[i]->m_间隔宽度;
				mat.row0.y += box.m_W[i]->m_间隔宽度;
				快捷栏->m_文字绘制.f_设置文本({ mat.row0 , mat.row1 }, S_UI主题::uic_文字颜色, i, box.m_W[i]->m_WName);
			}
			
			S_LineProp 线属性 = { 1.0, f_PackData4X8(S_UI主题::uic_列表行A), f_PackData4X8(S_UI主题::uic_列表行B)};
			mat3X2 mat;
			mat.row0 = box.m_W[1]->m_Pos;
			mat.row1 = box.m_W[1]->m_Size;
			mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
			快捷栏->m_背景绘制.f_alloc(2);
			快捷栏->m_背景绘制.f_set单色线(0, mat, 线属性, S_Widget预设图元::m_圆角矩形);
			
			mat.row0 = box.m_W[2]->m_Pos;
			mat.row1 = box.m_W[2]->m_Size;
			mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
			快捷栏->m_背景绘制.f_set单色线(1, mat, 线属性, S_Widget预设图元::m_矩形);
			
		}

		
	}

	
}

static void on_目录文件快捷栏布局(C_Widget* self, C_Widget** w, uint32 num) {
	w[0]->f_setSize(self->m_Size);
	{
		auto 滚动窗口组件 = w[0]->f_get更新部件();

		滚动窗口组件.m_W[0]->f_setX(0);
		滚动窗口组件.m_W[0]->f_setW(w[0]->m_Size.x - (S_UI主题::ui_滚动条厚度 + 10));

		f_布局_纵向滚动条(滚动窗口组件.m_W[1], w[0]->m_Size, 5);
	}
}

static bool on_目录文件快捷栏_鼠标滚轮(C_Widget* self, const S_鼠标& 鼠标) {
	C_列表框* box = dynamic_cast<C_列表框*>(self);

	f_布局_组件纵向滚动(self, f_ui_get滚动框视口(self), C_Widget::g_鼠标.lZ * 40);

	self->m_父部件->m_绘制属性更新 = true;
	return true;
}


static bool on_快捷栏打开关闭(C_Widget* self, bool show) {
	assert(dynamic_cast<C_目录文件快捷栏*>(self));
	C_目录文件快捷栏* box = (C_目录文件快捷栏*)(self);

	box->m_盘列表;

	//std::filesystem::path path;
	std::string path;
	uint8 offset = 0;
	for (uint8 i='a'; i<'z'; ++i) {
		path = i;
		path += ":/";

		//碰到盘不能读就会异常
		std::filesystem::path 路径 = path;
		try {
			//std::filesystem::permissions()
			std::error_code ec;
			bool fuck = std::filesystem::exists(路径, ec);
			if (fuck) {
				S_列表填充数据 item;
				item.m_ico = "07";
				item.m_ico_color = S_UI主题::uic_文字颜色;
				item.m_item.push_back(f_StringToWString(path));

				box->m_盘列表->f_addItem(item, offset);
				++offset;
			}
		}
		catch (std::filesystem::filesystem_error const& ex) {
			std::cout
				<< "what():  " << ex.what() << '\n'
				<< "path1(): " << ex.path1() << '\n'
				<< "path2(): " << ex.path2() << '\n'
				<< "code().value():    " << ex.code().value() << '\n'
				<< "code().message():  " << ex.code().message() << '\n'
				<< "code().category(): " << ex.code().category().name() << '\n';
		}

	}
	
	return true;
}





static bool f_目录文件快捷栏列表项选中回调(C_Widget* self, const std::vector<std::wstring>& filenames) {
	C_目录文件快捷栏* box = (C_目录文件快捷栏*)self->m_父部件->m_父部件->m_父部件->m_父部件;

	C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(box->m_文件列表->m_父部件);
	//filedialog->m_文件路径 = filenames[0];
	filedialog->m_路径 = filenames[0];

	if (filedialog->m_文件处理方式 == E_对话框类型::e_写入 || filedialog->m_文件处理方式 == E_对话框类型::e_读取) {
		f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径, filedialog->m_文件后缀);
	}
	else {
		f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径, filedialog->m_文件后缀, false);
	}

	filedialog->mui_右_浏览列表->m_绘制属性更新 = true;
	return true;
}

C_目录文件快捷栏::C_目录文件快捷栏(S_UI创建环境& ctx) : C_Widget(&ctx) {

	mf_布局Fun = on_目录文件快捷栏布局;
	mf_DrawFun = f_目录文件快捷栏绘制;
	mf_变换修改 = f_目录文件快捷栏变换修改;
	mf_打开关闭 = on_快捷栏打开关闭;

	C_动态分列栏* 动态分列栏_滚动视口 = new C_动态分列栏(ctx);
	//f_widget_开启视口属性(view);
	//view->mf_鼠标滚轮 = on_目录文件快捷栏_鼠标滚轮;
	C_滚动框* 滚动框 = new C_滚动框(ctx, false, true, 动态分列栏_滚动视口);
	滚动框->mf_鼠标滚轮 = on_目录文件快捷栏_鼠标滚轮;
	//C_滚动条* sh = new C_滚动条(ctx, E_方向::e_纵向);


	//f_添加子组件(view);
	f_添加子组件(滚动框);
	{
		动态分列栏_滚动视口->m_间隔宽度 = 10;
		{
			m_盘列表 = new C_列表框(ctx, 10, E_列表显示模式::e_列表模式_垂直);
			m_盘列表->mf_项选中回调 = f_目录文件快捷栏列表项选中回调;
			m_盘列表->mf_鼠标滚轮 = nullptr;

			C_展开栏* 展开框 = new C_展开栏(ctx, m_盘列表);
			展开框->m_WName = L"盘:";
			展开框->f_setSize({ 300,400 });
			展开框->m_间隔宽度 = 8;
			动态分列栏_滚动视口->f_添加子组件(展开框);


			m_收藏目录列表 = new C_列表框(ctx, 10, E_列表显示模式::e_列表模式_垂直);
			m_收藏目录列表->mf_鼠标滚轮 = nullptr;
			//m_收藏列表->mf_文件选中回调 = f_目录文件快捷栏列表项选中回调;
			展开框 = new C_展开栏(ctx, m_收藏目录列表);
			展开框->m_WName = L"收藏:";
			展开框->f_setSize({ 300,400 });
			展开框->m_间隔宽度 = 8;
			动态分列栏_滚动视口->f_添加子组件(展开框);


			m_系统目录列表 = new C_列表框(ctx, 10, E_列表显示模式::e_列表模式_垂直);
			m_系统目录列表->mf_鼠标滚轮 = nullptr;
			//m_收藏列表->mf_文件选中回调 = f_目录文件快捷栏列表项选中回调;
			展开框 = new C_展开栏(ctx, m_系统目录列表);
			展开框->m_WName = L"系统目录:";
			展开框->f_setSize({ 300,400 });
			展开框->m_间隔宽度 = 8;
			动态分列栏_滚动视口->f_添加子组件(展开框);


			m_最近文件列表 = new C_列表框(ctx, 10, E_列表显示模式::e_列表模式_垂直);
			m_最近文件列表->mf_鼠标滚轮 = nullptr;
			//m_收藏列表->mf_文件选中回调 = f_目录文件快捷栏列表项选中回调;
			展开框 = new C_展开栏(ctx, m_最近文件列表);
			展开框->m_WName = L"最近文件:";
			展开框->f_setSize({ 300,400 });
			展开框->m_间隔宽度 = 8;
			动态分列栏_滚动视口->f_添加子组件(展开框);
		}
	}


	m_单色块使用计数 = 4;

}

C_目录文件快捷栏::~C_目录文件快捷栏() {
}

void C_目录文件快捷栏::f_刷新盘符() {

}

void C_目录文件快捷栏::f_刷新收藏() {

}

void C_目录文件快捷栏::f_刷新历史() {

}







static void f_盘符和浏览记录布局(C_Widget* self, C_Widget** w, uint32 num) {
	
}

static void f_文件列表浏览布局(C_Widget* self, C_Widget** w, uint32 num) {
	//C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(self->m_父部件);
	f_VBOX布局(self, w, num);
}






static bool f_列表项选中回调(C_Widget* self, const std::vector<std::wstring>& filenames) {
	C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(self->m_父部件->m_父部件->m_父部件);
	C_Widget* 浏览列表 = self->m_父部件->m_父部件;

	if (filedialog) {
		std::string path = filedialog->m_路径.string();

		g当前要处理文件.clear();

		g显示文件名 = L"";
		for (const auto& name : filenames) {
			std::filesystem::path filepath = path;
			filepath /= name;

			//=========== 进入子目录 ===========
			if (f_file_路径是否为目录(filepath.string())) {
				S_目录文件包 files;

				if (f_file_get目录下所有文件名(filepath.string(), files, filedialog->m_文件后缀)) {
					std::vector<S_列表填充数据> data;
					for (auto& s : files.目录) {
						data.push_back({ "black319", S_UI主题::uic_文件夹, {s, L"", L""} });
					}
					if (filedialog->m_文件处理方式 == E_对话框类型::e_写入 || filedialog->m_文件处理方式 == E_对话框类型::e_读取) {
						for (auto& s : files.文件) {
							data.push_back({ "document", S_UI主题::uic_文件, {s, L"", L""} });
						}
					}

					C_列表框* listBox = dynamic_cast<C_列表框*>(self);
					listBox->f_填充列表(data);
					filedialog->mui_右_浏览列表->m_绘制属性更新 = true;

					g显示文件名 = L"";
					//g当前要处理文件.clear();
					g当前要处理文件.push_back(filepath.string());

					filedialog->m_路径 = filepath;

				}

				break;
			}
			else {
				g当前要处理文件.push_back(path);
			}


			if (g显示文件名.size()) g显示文件名 += L"; ";
			g显示文件名 += name;
		}

		//============================ 文件名编辑框更新 ========================
		if (g显示文件名.size()) {
			//文件名编辑框文本设置
			filedialog->mui_文件名编辑框->f_set文本(g显示文件名);
		}
		
		filedialog->mui_文件路径编辑框->f_set文本(filedialog->m_路径.wstring());

	}

	return true;
}




/*static bool on_浏览列表子部件鼠标进入(C_Widget* self, const S_鼠标& 轮值) {
	C_Widget* 父部件 = self->m_父部件;

	uint32* 颜色 = f_vg_map绘制数据指针<uint32>(父部件->m_画布, gDraw文件列表_文件夹浏览功能_面颜色ID);

	颜色[self->m_实例ID] = f_PackData4X8(self->m_颜色B);

	f_vg_unmap绘制数据指针(父部件->m_画布, gDraw文件列表_文件夹浏览功能_面颜色ID);
	return false;
}*/

/*static bool on_浏览列表子部件鼠标移出(C_Widget* self, const S_鼠标& 轮值) {
	C_Widget* 父部件 = self->m_父部件;

	uint32* 颜色 = f_vg_map绘制数据指针<uint32>(父部件->m_画布, gDraw文件列表_文件夹浏览功能_面颜色ID);

	颜色[self->m_实例ID] = f_PackData4X8(self->m_颜色A);

	f_vg_unmap绘制数据指针(父部件->m_画布, gDraw文件列表_文件夹浏览功能_面颜色ID);
	return false;
}*/

















static bool on_父级文件夹鼠标点击(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(self->m_父部件->m_父部件->m_父部件);

	//C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(浏览列表->m_父部件);
	//filedialog->路径 = filedialog->m_文件路径;
	filedialog->m_路径 = filedialog->m_路径.parent_path();
	
	if (filedialog->m_文件处理方式 == E_对话框类型::e_写入 || filedialog->m_文件处理方式 == E_对话框类型::e_读取) {
		f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径.string(), filedialog->m_文件后缀);
	}
	else if (filedialog->m_文件处理方式 == E_对话框类型::e_打开路径) {
		f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径.string(), filedialog->m_文件后缀, false);
	}
	//f_文件列表加入项(filedialog->mui_列表框, filedialog->m_路径.string(), filedialog->m_文件后缀);
	return true;
}

bool on_文件对话框确定(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(self->m_父部件->m_父部件->m_父部件);

	if (filedialog) {
		for (auto& e : g当前要处理文件) {
			if (filedialog->m_文件处理方式 == E_对话框类型::e_写入 || filedialog->m_文件处理方式 == E_对话框类型::e_读取) {
				if (f_file_路径是否为目录(e)) {
					if (e.back() != '/' && e.back() != '\\') e += '/';
					e += f_WStringToString(filedialog->mui_文件名编辑框->m_Text);
				}

				auto 扩展名 = f_file_文件扩展名(e);
				if (扩展名 != filedialog->m_文件后缀) {
					if (e.back() == '.') {
						e.pop_back();
					}
					e += filedialog->m_文件后缀;
				}
			}
			else if (filedialog->m_文件处理方式 == E_对话框类型::e_打开路径) {
				if (f_file_路径是否为目录(e) == false) {
					e = f_file_get路径(e);
				}
			}
		}

		
		if (filedialog->mui_负责打开的组件) {
			filedialog->mui_负责打开的组件->m_绘制属性更新 = true;
			filedialog->mui_负责打开的组件 = nullptr;
		}
		filedialog->mf_文件处理回调(filedialog, g当前要处理文件, filedialog->m_文件处理方式);

		g当前要处理文件.clear();
	}


	auto* gm = filedialog->f_get窗口管理();
	if (gm) f_widget_交换顶层组件(gm, 0);
	return true;
}

static bool on_取消按钮鼠标点击(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(self->m_父部件->m_父部件->m_父部件);

	filedialog->m_路径 = filedialog->m_路径.parent_path();
	//C_文件对话框* dig = dynamic_cast<C_文件对话框*>(self->m_父部件->m_父部件);
	if (filedialog) {
		filedialog->mf_文件处理回调(filedialog, {}, E_对话框类型::e_关闭);
	}

	f_widget_交换顶层组件(filedialog, 0);
	//auto* gm = filedialog->f_get窗口管理();
	//if (gm) f_widget_交换顶层组件(gm, 0);
	return true;
}

static void on_文件列表_滚动框布局(C_Widget* self, C_Widget** w, uint32 num) {
	C_列表框* box = dynamic_cast<C_列表框*>(w[0]);

	uint32 itemNum = box->m_列表数据.size();
	box->f_setH(itemNum * box->m_行高度);
	box->f_setW(self->m_Size.x);
	//box->f_setSize(self->m_Size);

	f_布局_扩展视口纵向滚动(self, w[0], 0);
}










static bool f_文件对话框打开关闭(C_Widget* self, bool show) {
	auto e = self->mf_get更新组件(self);
	C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(self);
	g_文件处理方式 = filedialog->m_文件处理方式;
	
	if (e.m_W[0]->mf_打开关闭) e.m_W[0]->mf_打开关闭(e.m_W[0], show);
	
	if (filedialog->m_文件处理方式 == E_对话框类型::e_读取 || filedialog->m_文件处理方式 == E_对话框类型::e_写入) {
		f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径, filedialog->m_文件后缀);
	}
	else if (filedialog->m_文件处理方式 == E_对话框类型::e_打开路径) {
		f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径, filedialog->m_文件后缀, false);
	}
	
	filedialog->mui_文件名编辑框->f_set文本(g显示文件名);
	filedialog->mui_文件路径编辑框->f_set文本(filedialog->m_路径.wstring());
	filedialog->m_绘制属性更新 = true;
	return true;
}



C_文件对话框::C_文件对话框(S_UI创建环境& ctx) : C_分割框(ctx) {
	m_文件处理方式 = E_对话框类型::e_读取;
	mui_负责打开的组件 = nullptr;
	//m_UIctx = &ctx;
	mf_打开关闭 = f_文件对话框打开关闭;
	m_TypeName = DEF_WIDGET_对话框;
	
	
	mui_左边_盘符记录 = new C_目录文件快捷栏(ctx);
	mui_左边_盘符记录->m_TypeName = "盘符记录";

	mui_右_浏览列表 = new C_Widget();
	mui_右_浏览列表->m_TypeName = "浏览列表";

	mui_左边_盘符记录->m_文件列表 = mui_右_浏览列表;

	f_add分割(mui_左边_盘符记录, 0.2f);
	f_add分割(mui_右_浏览列表, 1.0f);
	
	{
		//盘符记录->mf_布局Fun = f_盘符和浏览记录布局;
	}
	
	{
		auto* 导航栏 = new C_Widget();
		auto* 文件项 = new C_Widget();
		导航栏->f_setH(24);
		文件项->f_setH(24);

		导航栏->m_是否延展.x = true;
		文件项->m_是否延展.x = true;
		导航栏->mf_布局Fun = f_HBOX布局;
		文件项->mf_布局Fun = f_HBOX布局;
		{
			C_按钮* 前一个文件夹 = new C_按钮(&ctx, nullptr);
			C_按钮* 后一个文件夹 = new C_按钮(&ctx, nullptr);
			C_按钮* 父级文件夹 = new C_按钮(&ctx, nullptr);
			C_按钮* 刷新文件夹 = new C_按钮(&ctx, nullptr);
			C_按钮* 新建文件夹 = new C_按钮(&ctx, nullptr);
			mui_文件路径编辑框 = new C_行编辑框(ctx);
			C_行编辑框* 文件搜索 = new C_行编辑框(ctx);

			前一个文件夹->f_setSize({ 20,20 });
			后一个文件夹->f_setSize({ 20,20 });
			父级文件夹->f_setSize({ 20,20 });
			刷新文件夹->f_setSize({ 20,20 });
			新建文件夹->f_setSize({ 20,20 });

			{
				前一个文件夹->m_绘制标题 = false;
				前一个文件夹->m_绘制图标 = true;
				前一个文件夹->m_ICO = "arrow_left";
				后一个文件夹->m_绘制标题 = false;
				后一个文件夹->m_绘制图标 = true;
				后一个文件夹->m_ICO = "15";

				父级文件夹->mf_鼠标按键点击 = on_父级文件夹鼠标点击;
				父级文件夹->m_绘制标题 = false;
				父级文件夹->m_绘制图标 = true;
				父级文件夹->m_ICO = "17";

				刷新文件夹->m_绘制标题 = false;
				刷新文件夹->m_绘制图标 = true;
				刷新文件夹->m_ICO = "arrows64";
			}
			

			导航栏->f_添加子组件(前一个文件夹);
			导航栏->f_添加子组件(后一个文件夹);
			导航栏->f_添加子组件(父级文件夹);
			导航栏->f_添加子组件(刷新文件夹);
			导航栏->f_添加子组件(新建文件夹);
			导航栏->f_添加子组件(mui_文件路径编辑框);
			导航栏->f_添加子组件(文件搜索);

			mui_文件路径编辑框->m_是否延展.x = true;
			文件搜索->m_是否延展.x = true;


			mui_文件名编辑框 = new C_行编辑框(ctx);
			mui_文件名编辑框->m_是否延展.x = true;
			mui_打开or确定 = new C_按钮(&ctx, nullptr, L"确定");
			C_按钮* 取消 = new C_按钮(&ctx, nullptr, L"取消");
			mui_打开or确定->f_setSize({ 100,20 });

			取消->mf_鼠标按键点击 = on_取消按钮鼠标点击;
			mui_打开or确定->mf_鼠标按键点击 = on_文件对话框确定;

			取消->f_setSize({ 100,20 });
			文件项->f_添加子组件(mui_文件名编辑框);
			文件项->f_添加子组件(mui_打开or确定);
			文件项->f_添加子组件(取消);
		}

		mui_右_浏览列表->f_添加子组件(导航栏);
		//===================== 中间文件列表 ========================
		{
			mui_列表框 = new C_列表框(ctx, 3, E_列表显示模式::e_列表模式_垂直);
			C_滚动框* listFile = new C_滚动框(ctx, true, true, mui_列表框);
			listFile->m_实例ID = 10;

			mui_列表框->mf_项选中回调 = f_列表项选中回调;
			
			//mui_列表框 = fileView;
			listFile->m_是否延展.x = true;
			listFile->m_是否延展.y = true;
			listFile->mf_布局Fun = on_文件列表_滚动框布局;
			listFile->mf_鼠标滚轮 = nullptr;


			mui_右_浏览列表->f_添加子组件(listFile);


		}
		mui_右_浏览列表->f_添加子组件(文件项);
		mui_右_浏览列表->mf_布局Fun = f_VBOX布局;
	}
	
	return;

}

void C_文件对话框::f_set对话框模式(E_对话框类型 类型) {
	m_文件处理方式 = 类型;
	//auto e = mui_列表框->mf_get更新组件(mui_列表框);
	//f_vg_set文本(mui_右_浏览列表->m_画布, mui_右_浏览列表->m_文本对象, 2, L"取消");
	if (m_文件处理方式 == E_对话框类型::e_读取) {
		mui_打开or确定->m_WName = L"打开";
	}
	else if (m_文件处理方式 == E_对话框类型::e_写入) {
		mui_打开or确定->m_WName = L"保存";
	}
	else if (m_文件处理方式 == E_对话框类型::e_打开路径) {
		mui_打开or确定->m_WName = L"确定";
	}
	mui_打开or确定->m_绘制属性更新 = true;
}









static C_路径编辑器* g_当前路径编辑组件 = nullptr;

static void on_路径编辑器布局(C_Widget* self, C_Widget** w, uint32 num) {
	//w[0]->f_setLoc({ S_UI主题::ui_面板圆角半径,0 });
	//w[0]->f_setW(self->m_Size.x - self->m_Size.y - S_UI主题::ui_面板圆角半径);
	w[0]->f_setW(self->m_Size.x - self->m_Size.y);
	w[0]->f_setH(self->m_Size.y);

	w[1]->f_setPos({ self->m_Size.x - self->m_Size.y, 0.0 });
	w[1]->f_setSize({ self->m_Size.y, self->m_Size.y });

	if (self->mf_当前部件属性修改) {
		self->mf_当前部件属性修改(w[0], E_UI绘制调整部分::e_位置);
		self->mf_当前部件属性修改(w[1], E_UI绘制调整部分::e_位置);
	}
}

static void on_路径编辑器按钮单击(struct S_Props& prop) {
	C_按钮* but = dynamic_cast<C_按钮*>(prop.m_UI->m_部件);

	C_路径编辑器* box = (C_路径编辑器*)(but->m_父部件);
	box->m_对话框是否打开 = false;
	box->m_路径->m_值元素个数 = 0;
	if (box->m_路径->m_UI->m_Update) box->m_路径->m_UI->m_Update(*(box->m_路径));


	box->mui_对话框->f_set对话框模式(box->m_对话框类型);
	box->mui_对话框->mf_文件处理回调 = box->mf_对话框回调;
	//box->m_路径->m_值元素个数 = 1;
	//if (box->mui_对话框->m_文件路径.empty()) {
	//	box->mui_对话框->m_文件路径 = L"c:/";
	//}
	if (box->mui_对话框->m_路径.empty()) {
		box->mui_对话框->m_路径 = f_prop_Path(*(box->m_路径));
	}


	g_当前路径编辑组件 = box;
	box->mui_对话框->mui_负责打开的组件 = box;
	f_widget_交换顶层组件(box->mui_对话框, box->mui_对话框->m_实例ID);
}
static bool f_路径编辑器按钮单击(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_按钮* but = dynamic_cast<C_按钮*>(self);
	if (but->m_Op.m_UI->m_Update) {
		//but->m_Op->m_Func(but->m_Op->m_Obj);
	}

	C_路径编辑器* box = (C_路径编辑器*)(self->m_父部件);
	box->m_对话框是否打开 = false;
	if (box->m_路径->m_UI->m_Update) box->m_路径->m_UI->m_Update(*(box->m_路径));


	box->mui_对话框->f_set对话框模式(box->m_对话框类型);
	box->mui_对话框->mf_文件处理回调 = box->mf_对话框回调;
	//if (box->mui_对话框->m_文件路径.empty()) {
	//	box->mui_对话框->m_文件路径 = L"c:/";
	//}
	if (box->mui_对话框->m_路径.empty()) {
		box->mui_对话框->m_路径 = f_prop_Path(*(box->m_路径));
	}


	g_当前路径编辑组件 = box;
	box->mui_对话框->mui_负责打开的组件 = box;
	f_widget_交换顶层组件(box->mui_对话框, box->mui_对话框->m_实例ID);
	
	return true;
}

static bool on_文件处理回调(C_Widget* self, const std::vector<std::string>& name, E_对话框类型 方式)  {
	C_文件对话框* dialg = (C_文件对话框*)self;

	g_当前路径编辑组件->m_对话框是否打开 = true;
	if (g_当前路径编辑组件->m_路径 && name.size()) {
		f_prop_Path(*(g_当前路径编辑组件->m_路径)) = name[0];
		self->m_绘制属性更新 = true;

		((C_行编辑框*)g_当前路径编辑组件->m_子组件[0])->f_set文本(f_prop_Path(*(g_当前路径编辑组件->m_路径)));

		g_当前路径编辑组件->m_路径->m_值元素个数 = name.size();
		g_当前路径编辑组件->m_路径->m_UI->m_Update(*g_当前路径编辑组件->m_路径);
	}
	g_当前路径编辑组件 = nullptr;
	return true;
}
static void on_路径编辑框输入完成(C_Widget* self) {
	C_行编辑框* box = (C_行编辑框*)(self);
	C_路径编辑器* pathBox = (C_路径编辑器*)(box->m_父部件);

	if (pathBox->m_路径) {
		if (f_prop_Path(*(pathBox->m_路径)) != box->m_Text) {
			pathBox->m_路径->m_UI->m_Update(*pathBox->m_路径);
		}
		f_prop_Path(*(pathBox->m_路径)) = box->m_Text;
	}
}

C_路径编辑器::C_路径编辑器(S_UI创建环境& ctx, C_文件对话框* 对话框) {
	m_路径 = nullptr;
	mui_对话框 = 对话框;
	mf_布局Fun = on_路径编辑器布局;
	mf_对话框回调 = on_文件处理回调;
	m_对话框类型 = E_对话框类型::e_读取;

	m_对话框打开按钮 = f_alloc_OpsProp(on_路径编辑器按钮单击, L"打开");
	m_对话框打开按钮.m_私有 = true;
	auto but = f_ui_创建按钮(&ctx, &m_对话框打开按钮);
	//but->mf_鼠标按键点击 = f_路径编辑器按钮单击;

	but->m_颜色A = S_UI主题::uic_按钮;
	but->m_颜色B = S_UI主题::uic_按钮背景;
	but->m_图元 = S_Widget预设图元::m_右圆角矩形;


	auto edit = new C_行编辑框(ctx);
	edit->m_颜色A = S_UI主题::uic_行编辑框背景;
	edit->m_颜色B = S_UI主题::uic_行编辑框边框;
	edit->m_图元 = S_Widget预设图元::m_左圆角矩形;
	edit->m_文本对齐偏移.x = S_UI主题::ui_面板圆角半径*1.5;
	edit->m_文本对齐偏移.y = -1.0;
	edit->mf_文本输入完成 = on_路径编辑框输入完成;

	f_添加子组件(edit);
	f_添加子组件(but);
}

C_路径编辑器::~C_路径编辑器() {
}








static bool on_下拉列表按钮鼠标进入(C_Widget* self, const S_鼠标& 鼠标) {
	//self->m_颜色A = self->m_颜色A + S_RGBA8UI{ 50, 50, 50, 127 };
	//self->m_父部件->m_绘制属性更新 = true;
	return false;
}

static bool on_下拉列表按钮鼠标退出(C_Widget* self, const S_鼠标& 鼠标) {
	//self->m_颜色A = self->m_颜色B;
	//self->m_父部件->m_绘制属性更新 = true;
	return false;
}


static void on_超级列表编辑框布局(C_Widget* self, C_Widget** w, uint32 num) {
	C_超级列表编辑框* box = static_cast<C_超级列表编辑框*>(self);
	float32 size = self->m_Size.y;

	auto e = self->f_get更新部件();
	e.m_W[0]->f_setSize({ size, size });
	e.m_W[1]->f_setSize({ size, size });
	e.m_W[2]->f_setSize({ size, size });
	e.m_W[3]->f_setSize({ size, size });

	e.m_W[0]->m_是否延展 = { false, false };
	e.m_W[1]->m_是否延展 = { true, true };
	e.m_W[2]->m_是否延展 = { false, false };
	e.m_W[3]->m_是否延展 = { false, false };
	f_HBOX布局(self, e.m_W, e.m_Num);
}

static bool f_选择按钮单击(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_按钮* but = static_cast<C_按钮*>(self);

	C_超级列表编辑框* 超级列表编辑框 = static_cast<C_超级列表编辑框*>(but->m_父部件);
	g当前打开列表框的编辑框 = 超级列表编辑框;


	f_ui_绑定超级列表编辑框属性(超级列表编辑框, 超级列表编辑框->m_列表属性);

	vec2 pos = { self->m_裁剪大小.x, self->m_裁剪大小.w };
	auto 区域 = f_widget_get当前窗口矩形();
	
	超级列表编辑框->m_列表视口->f_setSize({ 200, 200 });
	
	pos = f_widget_弹出窗口坐标矫正(超级列表编辑框->m_列表视口, pos);
	if (pos.y + 超级列表编辑框->m_列表视口->m_Size.y >= 区域.w) {
		pos.y = self->m_裁剪大小.y - 超级列表编辑框->m_列表视口->m_Size.y;
	}

	超级列表编辑框->m_列表视口->f_setPos(pos);
	


	f_widget_顶层窗口_pop(0);
	f_widget_弹出顶层窗口(超级列表编辑框->m_列表视口);
	f_widget_线程定时关闭弹出组件(1000);

	f_widget_单个部件裁剪(
		超级列表编辑框->m_列表视口, 
		{ 0, 0, pos.x + 超级列表编辑框->m_列表视口->m_Size.x + 3, pos.y + 超级列表编辑框->m_列表视口->m_Size.y + 3 }, {} );

	return true;
}

static bool f_添加项按钮单击(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_按钮* but = static_cast<C_按钮*>(self);
	C_超级列表编辑框* 超级列表编辑框 = static_cast<C_超级列表编辑框*>(but->m_父部件);

	超级列表编辑框->m_列表视口;

	return true;
}

static bool f_删除项按钮单击(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_按钮* but = static_cast<C_按钮*>(self);
	C_超级列表编辑框* 超级列表编辑框 = static_cast<C_超级列表编辑框*>(but->m_父部件);

	超级列表编辑框->m_列表视口;

	return true;
}

static bool on_列表项选中回调(C_Widget* self, const S_列表填充数据& item) {
	if (g当前打开列表框的编辑框) {
		S_映射引用2D& 映射的数据 = f_prop_映射引用2D(g当前打开列表框的编辑框->m_列表属性);
		if (映射的数据.mf_元素选择) {
			
			auto 引用项 = f_prop_get2D映射引用项(g当前打开列表框的编辑框->m_列表属性, { uint32(item.m_ID_X), uint32(item.m_ID_Y) });
			((C_行编辑框*)g当前打开列表框的编辑框->m_文本编辑框)->f_set文本(引用项.m_Str);

			映射的数据.mf_元素选择(g当前打开列表框的编辑框, item);
		}
		return true;
	}
	return false;
}

C_超级列表编辑框::C_超级列表编辑框(S_UI创建环境& ctx) {
	mf_布局Fun = on_超级列表编辑框布局;

	m_选择按钮 = new C_按钮(&ctx, nullptr);
	m_文本编辑框 = new C_行编辑框(ctx);
	m_拷贝项按钮 = new C_按钮(&ctx, nullptr);
	m_添加项按钮 = new C_按钮(&ctx, nullptr);
	m_移除项按钮 = new C_按钮(&ctx, nullptr);


	m_列表视口 = new C_超级弹出菜单(ctx);
	
	m_选择按钮->m_ICO = "import";
	m_拷贝项按钮->m_ICO = "clipboard_copy";
	m_添加项按钮->m_ICO = "新建文件";
	m_移除项按钮->m_ICO = "删除";

	m_选择按钮->m_图元 = S_Widget预设图元::m_左圆角矩形;
	m_文本编辑框->m_图元 = S_Widget预设图元::m_矩形;
	m_拷贝项按钮->m_图元 = S_Widget预设图元::m_矩形;
	m_添加项按钮->m_图元 = S_Widget预设图元::m_矩形;
	m_移除项按钮->m_图元 = S_Widget预设图元::m_右圆角矩形;

	f_添加子组件(m_选择按钮);
	f_添加子组件(m_文本编辑框);
	f_添加子组件(m_拷贝项按钮);
	f_添加子组件(m_添加项按钮);
	f_添加子组件(m_移除项按钮);

	m_选择按钮->mf_鼠标按键点击 = f_选择按钮单击;
	m_添加项按钮->mf_鼠标按键点击 = f_添加项按钮单击;
	m_移除项按钮->mf_鼠标按键点击 = f_删除项按钮单击;


	f_ui_弹出面板项回调绑定(m_列表视口->m_弹出面板, on_列表项选中回调);
}

C_超级列表编辑框::~C_超级列表编辑框() {

}



C_Widget* f_ui_创建超级列表编辑框(S_UI创建环境& ctx, bool 项名称编辑, bool 列表项编辑) {
	C_超级列表编辑框* box = new C_超级列表编辑框(ctx);

	return box;
}

void f_ui_绑定超级列表编辑框属性(C_Widget* self, S_Props& prop) {
	C_超级列表编辑框* box = dynamic_cast<C_超级列表编辑框*>(self);
	box->m_列表属性 = prop;
	box->m_列表视口->m_弹出面板->m_Value = prop;

	auto itemData = f_prop_映射引用2D(prop);
	
	uint32 x_id = 0;
	for (auto& x : itemData.m_PtrItem) {
		uint32 y_id = 0;
		for (auto& y : *x) {
			S_列表填充数据 item{};

			item.m_item.push_back(y.m_Str);
			item.m_Data = y.m_Ptr;
			item.m_ico = y.m_Ico;
			item.m_ID_X = x_id;
			item.m_ID_Y = y_id;
			
			f_ui_添加弹出面板菜单项(box->m_列表视口->m_弹出面板, item, { x_id, y_id });
			++y_id;
		}

		++x_id;
	}

	//f_ui_弹出面板项回调绑定(box->m_列表视口->m_弹出面板, itemData.mf_元素选择);

	auto item = f_prop_get2D映射引用项(prop, itemData.m_当前项);
	((C_行编辑框*)box->m_文本编辑框)->f_set文本(item.m_Str);
}

void f_ui_绑定超级列表编辑框添加项回调消息(S_UI创建环境& ctx, bool 项名称编辑, bool 列表项编辑) {

}






